package com.atcumt.Carl.Greedy;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;

/**
 * 桶思想
 */
public class Greedy03 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();
        Greedy03 test = new Greedy03();
        test.GetEndPoint(s);
    }

    /**
     * 第一种情况：
     * i.设计桶的大小为 n + 1，则相同的任务恰好不能放入同一个桶（一行为一个桶），最密也只能放入相邻的桶；
     * ii.对于重复的任务，只能将每个都放入不同的桶中，因此桶的个数就是重复次数最多的任务的个数
     * iii.一个桶不管是否放满，其占用的时间均为 n + 1，这是因为后面桶里的任务需要等待冷却时间；
     * iv.最后一个桶是个特例，由于其后没有其他任务需等待，所以占用的时间为桶中的任务个数；
     * v.最终我们得到：总排队时间=（桶个数-1）*（n + 1）+ 最后一桶的任务数b.
     *
     * 第二种情况：
     * i.当任务重复率很低时，计算得到的桶个数很少
     * ii.但由于任务很多，可能出现桶不够用的情况，此时假想原来的桶被加长了，且所有的桶均装满，因此任务的总等待时间为任务总个数
     * (每个任务之间都不存在空余时间，冷却时间已经被完全填满了。)
     * iii.则对第一种情况和第二种情况的结果取最大值即可；
     *
     * 输入：tasks = ["A","A","A","B","B","B"], n = 2
     * 输出：8
     */
    public int leastInternal(char[] task, int n) {
        int[] bucket = new int[26];
        // max: 最大出现次数；cnt: 有多少种元素出现了 max 次
        int max = 0, cnt = 0;
        for (char c : task) {
            // 桶的个数就是重复次数最多的任务的个数
            max = Math.max(max, ++bucket[c - 'A']);
        }

        for (int e : bucket) {
            if (e == max) {
                cnt++;
            }
        }
        return Math.max((max - 1) * (n + 1) + cnt, task.length);
    }

    /**
     * 发送指令跟随坐标移动
     * n为0时，表示字符前没有数字，对应的key加1：n不为0时，表示前面有数字，对应的key加n
     */
    public int[] GetEndPoint (String order) {
        // write code here
        int[] point = {0, 0};
        int num = 0;
        String s = order.toUpperCase();
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                num = num * 10 + s.charAt(i) - '0';
            } else {
                map.put(s.charAt(i), num == 0 ? 1 : num);
                num = 0;
            }
        }
        Iterator<Map.Entry<Character, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Character, Integer> entry = iterator.next();
            if (entry.getKey() == 'W') {
                point[1] = entry.getValue();
            } else if (entry.getKey() == 'S') {
                point[1] = -entry.getValue();
            } else if (entry.getKey() == 'A') {
                point[0] = -entry.getValue();
            } else if (entry.getKey() == 'D') {
                point[0] = entry.getValue();
            }
        }
        return point;
    }

    /**
     * 手上有 n 朵花，每朵的花瓣数保存在一个数组中。我们每次可以选择任意一朵，拿走其中的一瓣或者两瓣，求掰完所有花的最少次数。
     * 贪心：能够拿两个花瓣就拿两个，仅剩一个的话就只拿一个
     */
    public int petalsBreak (int[] petals) {
        int res = 0;
        for (int i = 0; i < petals.length; i++) {
            res += petals[i] / 2; // 偶数
            res += petals[i] % 2; // 奇数
        }
        return res;
    }
}
